home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk10.zip / JMP.C < prev    next >
C/C++ Source or Header  |  1991-10-05  |  6KB  |  235 lines
  1.  
  2. /********************************************
  3. jmp.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13. /* $Log:    jmp.c,v $
  14.  * Revision 3.3.1.1  91/09/14  17:23:33  brennan
  15.  * VERSION 1.0
  16.  * 
  17.  * Revision 3.3  91/08/13  06:51:38  brennan
  18.  * VERSION .9994
  19.  * 
  20.  * Revision 3.2  91/06/28  04:16:53  brennan
  21.  * VERSION 0.999
  22.  * 
  23.  * Revision 3.1  91/06/07  10:27:42  brennan
  24.  * VERSION 0.995
  25.  * 
  26.  * Revision 2.2  91/05/22  07:30:39  brennan
  27.  * fixed stack underflow checks to work correctly on large model DOS
  28.  * 
  29.  * Revision 2.1  91/04/08  08:23:19  brennan
  30.  * VERSION 0.97
  31.  * 
  32. */
  33.  
  34. /* this module deals with back patching jumps, breaks and continues,
  35.    and with save and restoring code when we move code.
  36.    There are three stacks.  If we encounter a compile error, the
  37.    stacks are frozen, i.e., we do not attempt error recovery
  38.    on the stacks
  39. */
  40.  
  41.  
  42. #include "mawk.h"
  43. #include "jmp.h"
  44. #include "code.h"
  45. #include "sizes.h"
  46. #include "init.h"
  47. #include "memory.h"
  48.  
  49. extern unsigned compile_error_count ;
  50. #define error_state  (compile_error_count>0)
  51.  
  52.  
  53. /* a stack to hold jumps that need to be patched */
  54.  
  55. #define JMP_STK_SZ  (2*MAX_LOOP_DEPTH)
  56.  
  57. static INST **jmp_stack ; 
  58. static INST **jmp_sp  ;
  59.  
  60. /*-------------------------------------*/
  61. /* a stack to hold break or continue that need to be
  62.    patched (which is all of them) */
  63.  
  64. #define  BC_SZ    MAX_LOOP_DEPTH
  65.  
  66. /* the stack holds a linked list of these */
  67.  
  68. struct BC_node { /* struct for the break/continue list */
  69. char type ;   /*  'B' or 'C' */
  70. INST *jmp ;   /*  the jump to patch */
  71. struct BC_node *link ;
  72. } ;
  73.  
  74. static   struct BC_node  **BC_stack ;
  75. static   struct BC_node  **BC_sp ;
  76.  
  77. /*---------------------------------------*/
  78. /* a stack to hold some pieces of code while 
  79.    reorganizing loops */
  80.  
  81. #define  LOOP_CODE_SZ    (2*MAX_LOOP_DEPTH)
  82.  
  83. static struct loop_code {
  84. INST *code ;
  85. unsigned len ;
  86. }  *loop_code_stack , *lc_sp ;
  87.  
  88. /*--------------------------------------*/
  89. void jmp_stacks_init()
  90. { jmp_stack = (INST **)  zmalloc(JMP_STK_SZ*sizeof(INST*)) ;
  91.   jmp_sp = jmp_stack-1 ;
  92.  
  93.   BC_stack = (struct BC_node **) 
  94.               zmalloc(BC_SZ*sizeof(struct BC_node*)) ;
  95.   BC_sp =  BC_stack-1 ;
  96.  
  97.   loop_code_stack = (struct loop_code *)
  98.                     zmalloc(LOOP_CODE_SZ*sizeof(struct loop_code)) ;
  99.   lc_sp = loop_code_stack - 1 ;
  100. }
  101.  
  102. void jmp_stacks_cleanup()
  103. { zfree(jmp_stack, JMP_STK_SZ*sizeof(INST*)) ;
  104.   zfree(BC_stack, BC_SZ*sizeof(struct BC_node*)) ;
  105.   zfree(loop_code_stack, LOOP_CODE_SZ*sizeof(struct loop_code)) ;
  106. }
  107. /*--------------------------------------*/
  108. /* operations on the jmp_stack */
  109.  
  110. void code_jmp( jtype, target, expr_start)
  111.   int jtype ; 
  112.   INST *target ;
  113.   INST *expr_start ; /* used to recognize constant expressions,
  114.        which can only be _PUSHC , <address>  */
  115. { 
  116.   if (error_state)  return ;
  117.  
  118.   /* check if a constant expression will be at top of stack,
  119.      if so replace conditional jump with jump */
  120.  
  121.   if ( jtype != _JMP &&
  122.        code_ptr - 2 == expr_start &&
  123.        code_ptr[-2].op == _PUSHC )
  124.   { int t = test( (CELL *) code_ptr[-1].ptr ) ;
  125.     if ( jtype == _JZ && ! t ||
  126.          jtype == _JNZ && t )
  127.     { code_ptr -= 2 ; jtype = _JMP ; }
  128.   }
  129.    
  130.   if ( ! target ) /* jump will have to be patched later ,
  131.                      put it on the jmp_stack */
  132.   { if ( ++jmp_sp == jmp_stack + JMP_STK_SZ )
  133.           overflow("jmp stack" , JMP_STK_SZ ) ; 
  134.     *jmp_sp = code_ptr ;
  135.     code2(jtype, 0) ;
  136.   }
  137.   else
  138.   { INST *source = code_ptr ;
  139.   
  140.     code_ptr++->op = jtype ;
  141.     code_ptr++->op = target - source ; 
  142.   }
  143. }
  144.  
  145. void patch_jmp(target)  /* patch a jump on the jmp_stack */
  146.   INST *target ;
  147. { register INST *source ;
  148.  
  149.   if ( ! error_state )
  150.   {
  151.     if ( jmp_sp+1 <= jmp_stack ) bozo("jmp stack underflow") ;
  152.     source = *jmp_sp-- ;
  153.     source[1].op = target - source ;
  154.   }
  155. }
  156.  
  157.  
  158. /*---------------------------*/
  159.  
  160. /* a stack of linked lists of BC_nodes for patching 
  161.    break and continue statements.  */
  162.  
  163.  
  164. void BC_new()  /* push an empty list on the stack */
  165. { 
  166.   if ( ! error_state )
  167.   { if ( ++BC_sp == BC_stack + BC_SZ ) overflow("BC stack", BC_SZ) ;
  168.     * BC_sp = (struct BC_node *) 0 ;
  169.   }
  170. }
  171.  
  172. void BC_insert(type, address)
  173.   int type ; INST *address ;
  174. { register struct BC_node *p ; 
  175.  
  176.   if ( error_state )  return ;
  177.   if ( BC_sp <= BC_stack - 1 )
  178.   {  compile_error(  type == 'B' ?
  179.         "break statement outside of loop" :
  180.         "continue statement outside of loop" ) ; 
  181.      return ;
  182.   }
  183.   
  184.   p = (struct BC_node *) zmalloc( sizeof(struct BC_node) ) ;
  185.   p->type = type ; p->jmp = address ;
  186.   p->link = *BC_sp ; *BC_sp = p ;
  187. }
  188.  
  189. void BC_clear(B_address, C_address)  
  190. /* patch all break and continues on list */
  191. INST *B_address, *C_address ;
  192. { register struct BC_node *p , *q ;
  193.  
  194.   if (error_state) return ;
  195.   if ( BC_sp+1 <= BC_stack ) bozo("underflow on BC stack") ;
  196.   p = *BC_sp-- ;
  197.   while ( p )
  198.   { p->jmp[1].op = (p->type=='B' ? B_address : C_address) - p->jmp ;
  199.     q = p ; p = p->link ; zfree(q, sizeof(struct BC_node)) ;
  200.   }
  201. }
  202.  
  203. /*---------------------------------------------*/
  204. /*  save and restore some code for reorganizing
  205.     loops on a stack */
  206.  
  207.  
  208. void code_push( p, len)
  209.   INST *p ; unsigned len ;
  210. { 
  211.   if (error_state) return ;
  212.   if ( ++lc_sp == loop_code_stack + LOOP_CODE_SZ )
  213.         overflow("loop_code_stack" , LOOP_CODE_SZ) ;
  214.  
  215.   if ( len )
  216.   { lc_sp->code = (INST *) zmalloc(sizeof(INST) * len) ;
  217.     (void) memcpy(lc_sp->code, p, SIZE_T(sizeof(INST) * len)) ; }
  218.   else  lc_sp->code = (INST *) 0 ;
  219.   lc_sp->len = len ;
  220. }
  221.  
  222. /* copy the code at the top of the loop code stack to target.
  223.    return the number of bytes moved */
  224.  
  225. unsigned code_pop(target) 
  226.   INST *target ;
  227. { 
  228.   if (error_state)  return 0 ;
  229.   if ( lc_sp+1 <= loop_code_stack )  bozo("loop code stack underflow") ;
  230.   if ( lc_sp->len )
  231.   { (void) memcpy(target, lc_sp->code, SIZE_T(lc_sp->len * sizeof(INST))) ;
  232.     zfree(lc_sp->code, sizeof(INST)*lc_sp->len) ; }
  233.   return lc_sp-- -> len ;
  234. }
  235.